// 导入存储服务
const storageService = require('../../../services/storage')

Page({
  data: {
    isEditing: false, // 是否是编辑模式
    groupId: '', // 编组ID
    groupName: '', // 编组名称
    availableDevices: [], // 可选设备列表
    selectedDeviceIds: [], // 已选设备ID列表
    selectedDevices: [], // 已选设备对象列表
    deviceOptions: [], // 可变色复选列表数据
    canSave: false, // 是否可以保存
    groupDeviceType: null, // 新增：记录编组类型
  },

  onLoad: function (options) {
    console.log("options", options)
    // 加载所有设备并确保其为数组
    const deviceIds = storageService.getDeviceIds()
    const devices = []
    deviceIds.forEach(ele => {
      const dobj = storageService.getDeviceInfo(ele)
      if (dobj != null) {
        devices.push(dobj)
      }
    })

    // 判断是新建还是编辑
    if (options && options.groupInfo) {
      try {
        // 编辑现有编组
        const group = JSON.parse(decodeURIComponent(options.groupInfo))
        if (!group || typeof group !== 'object' || !group.deviceId || !group.deviceType) {
          throw new Error('无效的编组信息或缺少设备类型')
        }
        const groupType = group.deviceType // 获取编组的设备类型

        this.setData({
          isEditing: true,
          groupId: group.deviceId,
          groupName: group.name || '',
          selectedDeviceIds: Array.isArray(group.deviceIds) ? group.deviceIds : [],
          groupDeviceType: groupType // 设置编组类型
        })

        // 过滤出可用设备（类型相同，且（未在其他编组中或在当前编组中））
        const availableDevices = devices.filter(device => {
          return device.deviceType !== "orig_diy_lamp" && device.deviceType === groupType && (!device.inGroup || (device.inGroup && device.groupId === group.deviceId))
        })

        // 获取已选设备对象列表 (从过滤后的可用设备中找)
        const selectedDevices = availableDevices.filter(device =>
          this.data.selectedDeviceIds.includes(device.deviceId)
        )

        // 转换为deviceOptions格式
        const deviceOptions = availableDevices.map(device => ({
          deviceId: device.deviceId,
          label: device.name,
          totalSwitch: device.totalSwitch,
          checked: this.data.selectedDeviceIds.includes(device.deviceId),
          deviceType: device.deviceType // 确保包含设备类型
        }))

        const groupName = this.data.groupName || ''
        this.setData({
          availableDevices,
          selectedDevices,
          deviceOptions,
          canSave: groupName.trim() !== '' && this.data.selectedDeviceIds.length >= 2,
        })
      } catch (error) {
        console.error('解析或处理编组信息失败:', error)
        wx.showToast({
          title: '加载编组信息失败',
          icon: 'none'
        })
        // 可能需要返回或显示错误状态
        this.setData({
          canSave: false,
          availableDevices: [],
          deviceOptions: []
        }) // 清空以防万一
      }
    } else {
      // 创建新编组
      // 获取所有未分组的设备
      const availableDevices = devices.filter(device => !device.inGroup && device.deviceType !== "orig_diy_lamp")

      // 转换为deviceOptions格式，确保包含设备类型
      const deviceOptions = availableDevices.map(device => ({
        deviceId: device.deviceId,
        label: device.name,
        totalSwitch: device.totalSwitch,
        checked: false,
        deviceType: device.deviceType // 确保包含设备类型
      }))

      this.setData({
        availableDevices, // 存储所有未分组设备
        deviceOptions, // 显示给用户选择
        canSave: false,
        groupDeviceType: null // 初始化编组类型为null
      })
    }
  },

  // 编组名称输入处理
  onGroupNameInput: function (e) {
    const groupName = e.detail.value || ''
    this.setData({
      groupName,
      canSave: groupName.trim() !== '' && this.data.selectedDeviceIds.length >= 2,
    })
  },

  // 切换设备选择状态 - 可变色复选列表实现
  toggleSelect: function (e) {
    const index = e.currentTarget.dataset.index
    const deviceOptions = [...this.data.deviceOptions]
    const currentOption = deviceOptions[index]
    const currentDeviceId = currentOption.deviceId
    const currentDeviceType = currentOption.deviceType // 从选项中获取设备类型

    // --- 类型检查和筛选开始 ---
    if (!this.data.isEditing) {
      // 新建编组模式
      if (this.data.selectedDeviceIds.length === 0 && !currentOption.checked) {
        // 这是选择的第一个设备
        this.setData({
          groupDeviceType: currentDeviceType
        }) // 设置编组类型

        // 筛选设备选项，只显示相同类型的设备
        const filteredOptions = this.data.availableDevices
          .filter(device => device.deviceType === currentDeviceType)
          .map(device => ({
            deviceId: device.deviceId,
            label: device.name,
            totalSwitch: device.totalSwitch,
            checked: device.deviceId === currentDeviceId, // 当前选中的设备
            deviceType: device.deviceType
          }));

        // 更新显示的设备选项
        this.setData({
          deviceOptions: filteredOptions,
          selectedDeviceIds: [currentDeviceId],
          selectedDevices: [this.data.availableDevices.find(device => device.deviceId === currentDeviceId)]
        });

        const groupName = this.data.groupName || '';
        this.setData({
          canSave: groupName.trim() !== '' && this.data.selectedDeviceIds.length >= 2
        });

        return; // 已经处理完成，直接返回
      } else if (this.data.selectedDeviceIds.length > 0 && currentOption.checked) {
        // 这是取消选择一个设备
        if (this.data.selectedDeviceIds.length === 1 && this.data.selectedDeviceIds[0] === currentDeviceId) {
          // 取消选择唯一的设备，重置编组类型，恢复所有设备选项
          this.setData({
            groupDeviceType: null
          });

          // 恢复所有可选设备
          const allOptions = this.data.availableDevices.map(device => ({
            deviceId: device.deviceId,
            label: device.name,
            totalSwitch: device.totalSwitch,
            checked: false,
            deviceType: device.deviceType
          }));

          this.setData({
            deviceOptions: allOptions,
            selectedDeviceIds: [],
            selectedDevices: []
          });

          const groupName = this.data.groupName || '';
          this.setData({
            canSave: groupName.trim() !== '' && this.data.selectedDeviceIds.length >= 2
          });

          return; // 已经处理完成，直接返回
        }
      } else if (currentDeviceType !== this.data.groupDeviceType && !currentOption.checked) {
        // 尝试选择一个不同类型的设备 - 这种情况不应该发生，因为我们已经过滤了设备列表
        wx.showToast({
          title: '只能选择相同类型的设备进行编组',
          icon: 'none',
          duration: 2000,
        });
        return; // 阻止选择
      }
    } else {
      // 编辑模式下，类型在 onLoad 时已确定，此处无需额外检查，因为 deviceOptions 已被过滤
    }
    // --- 类型检查和筛选结束 ---

    // 检查是否已达到最大设备数量限制
    if (!currentOption.checked && this.data.selectedDeviceIds.length >= 30) {
      wx.showToast({
        title: '最多只能选择30台设备',
        icon: 'none',
        duration: 2000,
      });
      return;
    }

    // 切换选中状态
    deviceOptions[index].checked = !deviceOptions[index].checked;

    // 更新selectedDeviceIds和selectedDevices
    let selectedDeviceIds = [];
    let selectedDevices = [];

    deviceOptions.forEach((option, idx) => {
      if (option.checked) {
        selectedDeviceIds.push(option.deviceId);
        // 注意：这里应该从 this.data.availableDevices 中查找，而不是 this.data.devices
        const device = this.data.availableDevices.find(device => device.deviceId === option.deviceId);
        if (device) {
          selectedDevices.push(device);
        }
      }
    });

    const groupName = this.data.groupName || '';
    this.setData({
      deviceOptions,
      selectedDeviceIds,
      selectedDevices,
      canSave: groupName.trim() !== '' && selectedDeviceIds.length >= 2, // 至少需要2个设备才能保存编组
    });
  },

  // 取消编辑
  cancelEdit: function () {
    wx.navigateBack()
  },

  // 保存编组
  saveGroup: function () {
    // 验证输入
    if (!this.data.canSave) {
      return
    }
    if ("seawater_diy_lamp" === this.data.groupDeviceType) {
      let chsNum = -1
      let flag = false
      for (let i = 0; i < this.data.selectedDeviceIds.length; i++) {
        const chs = storageService.getDeviceChannels(this.data.selectedDeviceIds[i])
        if (!Array.isArray(chs)) {
          flag = true
          break
        }
        if (chsNum < 0) {
          chsNum = chs.length
        } else if (chsNum != chs.length) {
          flag = true
          break
        }
      }
      if (flag) {
        wx.showToast({
          title: '所选择的设备中通道数量不一致!',
          icon: 'none',
          duration: 3000,
        })
        return
      }
    }

    // 使用storage服务获取编组列表，确保返回数组
    const groupIds = storageService.getGroupIds()

    // 准备新编组数据
    let newGroup = {
      name: this.data.groupName.trim(),
      deviceIds: this.data.selectedDeviceIds,
      deviceType: null, // 初始化 deviceType
      totalSwitch: false,
      startTime: '--:--',
      endTime: '--:--'
    }

    if (this.data.isEditing) {
      // 编辑现有编组
      const groupIndex = groupIds.findIndex(id => id === this.data.groupId)
      if (groupIndex !== -1) {
        // 保留原编组ID和其他设置
        newGroup.deviceId = this.data.groupId
        const oldGroup = storageService.getDeviceInfo(this.data.groupId)
        newGroup.deviceType = oldGroup.deviceType // **保留原编组的类型**

        // 保留原编组的设置
        newGroup.totalSwitch = oldGroup.totalSwitch
        newGroup.startTime = oldGroup.startTime
        newGroup.endTime = oldGroup.endTime

        // **先保存编组列表**
        storageService.saveDeviceInfo(newGroup.deviceId, newGroup)

        // 处理设备的编组状态
        // 确保deviceIds是数组
        const oldDeviceIds = Array.isArray(oldGroup.deviceIds) ? oldGroup.deviceIds : []

        // 1. 找出从编组中移除的设备
        const removedDeviceIds = oldDeviceIds.filter(id => !newGroup.deviceIds.includes(id))
        // 2. 找出新添加到编组的设备
        const addedDeviceIds = newGroup.deviceIds.filter(id => !oldDeviceIds.includes(id))

        // 更新设备的编组状态并同步数据
        removedDeviceIds.forEach(deviceId => {
          // 从编组中移除的设备 - 清除同步状态
          storageService.clearDeviceGroupSyncData(deviceId)
        })
        addedDeviceIds.forEach(deviceId => {
          // 新添加到编组的设备 - 从编组同步数据
          storageService.syncDeviceDataFromGroup(deviceId, newGroup.deviceId)
        })
      } else {
        // 如果在编辑时找不到原始编组ID（理论上不太可能发生，除非数据被外部篡改）
        console.error(`尝试编辑不存在的编组 ID: ${this.data.groupId}`)
        wx.showToast({
          title: '保存失败，原始编组不存在',
          icon: 'none'
        })
        return
      }
    } else {
      // 创建新编组
      // **设置编组类型**
      newGroup.deviceType = this.data.groupDeviceType

      // 生成唯一ID
      const utils = require('../../../utils/utils')
      newGroup.deviceId = 'group_' + utils.generateRandomId(8)

      // 添加到编组列表
      groupIds.push(newGroup.deviceId)

      // **先保存编组列表**
      storageService.saveGroupIds(groupIds)
      storageService.saveDeviceInfo(newGroup.deviceId, newGroup)
      storageService.saveDeviceChannels(newGroup.deviceId, storageService.getDeviceChannels(newGroup.deviceIds[0]))

      // 更新设备的编组状态并同步数据
      newGroup.deviceIds.forEach(deviceId => {
        storageService.syncDeviceDataFromGroup(deviceId, newGroup.deviceId)
      })
    }

    // 使用storage服务保存编组数据 (设备数据已在 storageService 中保存)
    // storageService.saveGroups(groups) // **移动到上面**

    // 显示成功提示
    wx.showToast({
      title: this.data.isEditing ? '编组已更新' : '编组已创建',
      icon: 'success',
      duration: 2000,
    })
    storageService.setRefreshDevicesFlag()
    // 返回上一页
    setTimeout(() => {
      wx.navigateBack()
    }, 1500)
  },
})